import random
class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子
        self.parent=None

class BST:
    def __init__(self,li=None):
        self.root=None
        if li:
            for val in li:
                self.insert_no_rec(val)

    def query(self,node,val):
        if not node:
            return None
        if node.data<val:
            return self.query(node.rchild,val)
        elif node.data>val:
            return self.query(node.lchild,val)
        else:
            return node

    def query_not_rec(self,val):
        p=self.root
        while p:
            if p.data<val:
                p=p.rchild
            elif p.data>val:
                p=p.lchild
            else:
                return p
        return None

    # 情况一:node是叶子结点
    def __remove_node_1(self,node):
        if not node.parent:
            self.root=None
        if node==node.parent.lchild: #如果node是它父亲的左孩子
            node.parent.lchild=None
        else:
            node.parent.rchild=None

    def __remove_node_21(self,node):
        #情况2.1：只有一个左孩子
        if not node.parent: #根节点
            self.root=node.lchild
            node.lchild.parent=None
        elif node==node.parent.lchild:
            node.parent.lchild=node.lchild
            node.lchild.parent=node.parent
        else:
            node.parent.rchild=node.lchild
            node.lchild.parent=node.parent

    def __remove_node_22(self,node):
        #情况2.2：node只有一个右孩子
        if not node.parent:
            self.root=node.rchild
        elif node==node.parent.lchild:
            node.parent.lchild=node.rchild
            node.rchild.parent=node.parent
        else:
            node.parent.rchild=node.rchild
            node.rchild.parent=node.parent

    def delete(self,val):
        if self.root: #不是空树
            node=self.query_not_rec(val)
            if not node: #不存在
                return False
            if not node.lchild and not node.rchild: #1.叶子节点
                self.__remove_node_1(node)
            elif not node.rchild: #2.1只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild: #2.2只有一个右孩子
                self.__remove_node_22(node)
            else: #3. 两个孩子都有
                min_node=node.rchild
                while min_node.lchild:
                    min_node=min_node.lchild
                node.data=min_node.data
                #删除min_node
                if min_node.rchild:
                    self.__remove_node_22(node)
                else:
                    self.__remove_node_1(node)

    def insert(self,node,val):
        if not node:
            node=BiTreeNode(val)
        elif val<node.data:
            node.lchild=self.insert(node.lchild,val)
            node.lchild.parent=node
        elif val>node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node

    def insert_no_rec(self,val):
        p=self.root
        #空值时进行特殊处理
        if not p:
            self.root=BiTreeNode(val)
            return
        while True:
            if val<p.data:
                if p.lchild:
                    p=p.lchild
                else: #左子树不存在
                    p.lchild=BiTreeNode(val)
                    p.lchild.parent=p
                    return
            elif val>p.data:
                if p.rchild:
                    p=p.rchild
                else: #右子树不存在
                    p.rchild=BiTreeNode(val)
                    p.rchild.parent=p
                    return
            else:
                return

    # 前序遍历
    def pre_order(self,root):
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    # 中序遍历
    def in_order(self,root):
        if root:
            self.in_order(root.lchild)
            print(root.data, end=',')
            self.in_order(root.rchild)

    # 后序遍历
    def post_order(self,root):
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=',')
# li=list(range(0,500,2))
# random.shuffle(li)
# tree=BST(li)
# tree.delete(2)
# tree.pre_order(tree.root)
# print("")
# tree.in_order(tree.root)
# print("")
# tree.post_order(tree.root)
# print('')
# print(tree.query_not_rec(3))
